home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 1.iso / toolbox / www / cgi-bin / counter.pl < prev    next >
Encoding:
Perl Script  |  1996-11-11  |  19.2 KB  |  592 lines
  1. #!/usr/sbin/perl
  2. 'di ';
  3. 'ds 00 \\"';
  4. 'ig 00 ';
  5. #
  6. # $Id: counter.pl.m,v 1.3 1996/10/29 21:28:19 murphy Exp $
  7. # Copyright (C) 1994 Daniel F. Rich (drich@corp.sgi.com)
  8. # 
  9. #   This program is free software; you can redistribute it and/or modify
  10. #   it under the terms of the GNU General Public License as published by
  11. #   the Free Software Foundation; either version 2, or (at your option)
  12. #   any later version.
  13. #
  14. #   This program is distributed in the hope that it will be useful,
  15. #   but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. #   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17. #   GNU General Public License for more details.
  18. #
  19. # counter - increment a counter for WWW
  20. #
  21. # This program is its own manual page,  Install in man and bin.
  22. #
  23. # To install:
  24. #   1.    Change $defcounterfile below to point to the default file containing 
  25. #    the count, or run using the -f option.  This is the file that will be
  26. #    used if the counter URL is not found in the config file, or of the
  27. #    config file can't be opened.
  28. #
  29. #   2.    If you want to run the counter out of inetd, add the following lines
  30. #    to the files specified (the port in the services file, 8987, will be
  31. #    the port specified in the URL in step 5):
  32. #    /etc/services:
  33. #        counter 8987/tcp            # WWW visitor counter
  34. #    /etc/inetd.conf (or /usr/etc/inetd.conf)
  35. #        counter stream tcp nowait www /www/bin/counter counter
  36. #    The last three fields of the line above are the user to run the counter
  37. #    under (*must* have write access to the file specified by
  38. #    $defcounterfile), the path to the counter program, and the args to pass
  39. #    to the program respectively.  The first argument must be counter, and
  40. #    any other arguments may be added on after that.
  41. # 
  42. #   3.    If you wish to have a counter for more than one document, you will
  43. #    need to create a config file.  By default, this is named 
  44. #    'counter.conf' and is in the same directory as the counter script,
  45. #    but you can override this with the -c option.
  46. #
  47. #   4.    Test the script by running it from the command line.  If everything
  48. #    is correct, it should return an X11 bitmap containing the current 
  49. #    count.  You will want to run it with the input redirected from
  50. #    /dev/null, as it is expecting to see a document URL on standard input.
  51. #    Ex. ./counter.pl < /dev/null
  52. #    If you want to test it with a sample document name, just type something
  53. #    like:
  54. #        GET /counter.xbm HTTP/1.0
  55. #    after running the script.
  56. #
  57. #   5.    Now, to use this from your documents, just use a URL of the form:
  58. #        http://your.www.host:8987/counter.xbm
  59. #    where counter.xbm is replaced with the filenames in your config file.
  60. #    If you only wish to count a single document, the URL above should
  61. #    work fine.
  62. #
  63. # Written 3/8/94 by Dan Rich (drich@corp.sgi.com)
  64. #     Based on C code written by Frans van Hoesel (hoesel@chem.rug.nl)
  65. #
  66. # $Log: counter.pl.m,v $
  67. # Revision 1.3  1996/10/29  21:28:19  murphy
  68. # changes necessary to support forum 96 CD
  69. #
  70. # Revision 1.2  1996/04/22  13:38:28  DTjanitor
  71. # change .www references to .www_6.0
  72. #
  73. # Revision 1.1  1996/02/15  19:47:54  dave
  74. # adding in collapsed cgi-bin{int,ext,cd} files into their .m new forms
  75. #
  76. % Revision 1.6  1995/03/31  22:36:17  dave
  77. % updating files to conform to v5.0 CD
  78. %
  79. # Revision 1.4  1995/03/11  05:22:19  dave
  80. # fixed broken uncommented comment
  81. #
  82. #
  83. # Revision 1.5  1995/01/09  19:05:37  drich
  84. # Fixed a bug in the version number code.
  85. #
  86. # Revision 1.4  1995/01/06  00:42:42  drich
  87. # Added -V flag, and documentation for the '-f' option.
  88. # Also cleaned up the code so it runs with perl5.
  89. #
  90. # Revision 1.3  1994/10/25  13:31:38  drich
  91. # Fixed a socket bug, and corrected the URL where the program is available.
  92. #
  93. # Revision 1.2  1994/10/18  20:13:29  drich
  94. # Added daemon support and additional command line flags.
  95. # Also added new documentation (man page!!)
  96. #
  97. # Revision 1.1  1994/04/18  14:48:00  drich
  98. # Initial revision
  99. #
  100.  
  101. sub usage {
  102.     print STDERR "usage: $0 [-dziV] [-p port] [-f defaultcountfile | -c configfile] [-C interval] [-D level]\n";
  103.     exit 1;
  104. }
  105.  
  106. $userName = $ENV{'USER'};
  107. print $userName;
  108. $userName = "/usr/people/guest";
  109.  
  110.  
  111. #####################################
  112. # Setup/Define Machine-Specific stuff
  113. # reference the envariable DOCUMENT_ROOT directly
  114. # contents equal to the equivalent-on-your-machine of everything *inside*
  115. # the # single, "'", quotes:  '$DocumentRoot="/AbsPath/to/your/DocRoot"'
  116. # AND have it's path from the root directory of "/" be whatever makes
  117. # sense for you on your server machine--we originally put it in
  118. # /usr/tmp but this became unreliable since /usr/tmp/ IS "fair game"
  119. # for being completely cleaned out at any time.
  120. $DocumentRoot=$ENV{'DOCUMENT_ROOT'};
  121. $DocumentRoot="/usr/netsite-docs" unless $DocumentRoot;
  122.  
  123.  
  124. $defcounterfile = "$DocumentRoot/toolbox/www/misc/counter.txt";    # Default file containing the count
  125. $defport = 8987;        # Default port to run on (standalone)
  126. ($dirname,$basename) = ($0 =~ /^(.*)\/([^\/]*)$/);
  127. if (! $basename) {
  128.     $dirname=".";
  129.     $basename=$0;
  130. }
  131. $configfile = "$dirname/counter.conf";
  132.  
  133. sub debug_print {
  134.     local($level,$message) = @_;
  135.  
  136.     return    if (!defined($debug));
  137.     return      if ($level > $debug);
  138.     $message =~ s/\n(.)/\nDEBUG:$level:$1/g     if ($message =~ /\n./);
  139.     if ($nocr && ($olevel == $level)) {
  140.         print STDERR "$message" if ($level <= $debug);
  141.     } else {
  142.         print STDERR "\n"       if ($nocr);
  143.         print STDERR "DEBUG:$level:$message";
  144.     }
  145.     $olevel = $level;
  146.     $nocr = $message !~ /\n/;
  147. }
  148.  
  149. # Read in configuration file
  150. sub read_config {
  151.     local($sig) = @_;
  152.  
  153.     if ($sig eq 'HUP') {
  154.     &debug_print(1,"Caught a SIG $sig--reloading config file\n");
  155.     &syslog('info',"Caught a SIG $sig--reloading config file") && defined($syslog);
  156.     }
  157.  
  158.     @config=();
  159.     if ( -f "$configfile" ) {
  160.     &debug_print(1, "Reading config file: $configfile...");
  161.     open(CONFIG,"<$configfile") || &syslog('err',"err opening $configfile: $!");
  162.     while (<CONFIG>) {
  163.         chop;
  164.         s/#.*$//;
  165.         next    if (!$_);
  166.         ($url,$counter,$options) = split(/\s+/,$_,3);
  167.         $config{$url} = $counter;
  168.         $options{$url} = $options;
  169.         &debug_print(2,"    $url --> $counter");
  170.         &debug_print(2,"  w/zeros")        if ($options{$url} =~ /zero/);
  171.         &debug_print(2,"  inverse")        if ($options{$url} =~ /inverse/);
  172.         &debug_print(2,"\n");
  173.     }
  174.     close(CONFIG);
  175.     &debug_print(1, "done.\n");
  176.     }
  177.     $SIG{'HUP'} = 'read_config';
  178. }
  179.  
  180. sub give_up {
  181.     print STDERR "$_[0]\n";
  182.     &syslog('warning',"$_[0]\n")        if ($syslog);
  183.     exit 1;
  184. }
  185.  
  186. push(@INC,'/usr/local/lib/perl');
  187. require('getopts.pl') || &give_up("$0: can\'t do getopts.pl: $@");
  188. require('sys/file.ph') || &give_up("$0: can\'t do sys/file.ph: $@");
  189. require('sys/errno.ph') || &give_up("$0: can\'t do sys/errno.ph: $@");
  190. undef($syslog);            # True if we can use syslog
  191. require('syslog.pl') && ($syslog = 1);
  192.  
  193. if ( ! &Getopts('c:C:dD:f:ip:Vz') ) {
  194.     &usage;
  195. }
  196. $checkpoint = $opt_C;        # Checkpoint interval
  197. $daemon = $opt_d;        # Run as a daemon? (standalone)
  198. $debug = $opt_D;
  199. # Counter file name is specified by -f or the config file (-c)
  200. $defcounterfile = $opt_f            if ($opt_f);
  201. $definverse = $opt_i;        # Invert bitmap if true
  202. $port = $opt_p ? $opt_p : $defport; # Port to run on (standalone)
  203. $defleading_zero = $opt_z;    # Print leading zeros on count
  204.  
  205. # Print version info
  206. $version="\$Revision: 1.3 $_";
  207. $version =~ s/\$Revision: 1.3 $/\1/; # Strip the RCS version
  208. if ($debug || $opt_V) {
  209.     print STDERR "WWW counter, version $version\n\n";
  210.  
  211.     if (!$debug) {
  212.     print STDERR "\$RCSfile: counter.pl.m,v $ \$Revision: 1.3 $ \$Date: 1996/10/29 21:28:19 $ \n\n";
  213.  
  214.     print STDERR "Copyright (C) 1994 Daniel F. Rich (drich\@corp.sgi.com)\n\n";
  215.     
  216.     print STDERR "This program is free software; you can redistribute it and/or modify\n";
  217.     print STDERR "it under the terms of the GNU General Public License as published by\n";
  218.     print STDERR "the Free Software Foundation; either version 2, or (at your option)\n";
  219.     print STDERR "any later version.\n\n";
  220.     
  221.     print STDERR "This program is distributed in the hope that it will be useful,\n";
  222.     print STDERR "but WITHOUT ANY WARRANTY; without even the implied warranty of\n";
  223.     print STDERR "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n";
  224.     print STDERR "GNU General Public License for more details.\n";
  225.     }
  226. }
  227. exit    if ($opt_V);
  228.  
  229. # Check for valid arguments
  230. if ($checkpoint && ($checkpoint !~ /^\d+$/)) {
  231.     &usage;
  232. }
  233. if ($port && ($port !~ /^\d+$/)) {
  234.     &usage;
  235. }
  236.  
  237. &debug_print(1, "We have syslog!!\n")        if ($syslog);
  238. &openlog($basename,'cons,pid','daemon');
  239.  
  240. &read_config(0);
  241.  
  242. # Start up the daemon if needed
  243. if ($daemon) {
  244.     if (!$debug) {
  245.     # Fork off, so we are a true deamon!
  246.     unless (fork) {
  247.         unless (fork) {
  248.         sleep 1 until getppid == 1;
  249.         if ( -e "/dev/console" ) {
  250.             close(STDERR);
  251.             open(STDERR,"> /dev/console");
  252.         }
  253.         } else {
  254.         exit 0;
  255.         }
  256.     } else {
  257.         wait;
  258.         exit 0;
  259.     }
  260.     }
  261.  
  262.     close(STDIN);        # We will map this to our socket
  263.     close(STDOUT);
  264.  
  265.     require('sys/socket.ph') || &give_up("$0: can\'t do sys/socket.ph: $@");
  266.  
  267.     $sockaddr = 'S n a4 x8';
  268.     $proto = (getprotobyname('tcp'))[2];
  269.     $this = pack($sockaddr, &AF_INET, $port, "\0\0\0\0");
  270.     select(NS); $| = 1; select(stdout);
  271.  
  272.     socket(S, &AF_INET, &SOCK_STREAM, $proto) || &give_up("socket: $!");
  273.     bind(S,$this) || &give_up("bind: $!");
  274.     listen(S,5) || &give_up("connect: $!");
  275.  
  276.     select(S); $| = 1; select(stdout);
  277.  
  278.     &syslog('notice',"daemon started on port $port");
  279. }
  280.  
  281. # bitmap for each digit
  282. @digits = (0x00,0x00,0x00,0x3c,0x66,0x66,0x66,0x66,
  283.        0x66,0x66,0x66,0x66,0x3c,0x00,0x00,0x00,
  284.        0x00,0x00,0x00,0x30,0x38,0x30,0x30,0x30,
  285.        0x30,0x30,0x30,0x30,0x30,0x00,0x00,0x00,
  286.        0x00,0x00,0x00,0x3c,0x66,0x60,0x60,0x30,
  287.        0x18,0x0c,0x06,0x06,0x7e,0x00,0x00,0x00,
  288.        0x00,0x00,0x00,0x3c,0x66,0x60,0x60,0x38,
  289.        0x60,0x60,0x60,0x66,0x3c,0x00,0x00,0x00,
  290.        0x00,0x00,0x00,0x30,0x30,0x38,0x38,0x34,
  291.        0x34,0x32,0x7e,0x30,0x78,0x00,0x00,0x00,
  292.        0x00,0x00,0x00,0x7e,0x06,0x06,0x06,0x3e,
  293.        0x60,0x60,0x60,0x66,0x3c,0x00,0x00,0x00,
  294.        0x00,0x00,0x00,0x38,0x0c,0x06,0x06,0x3e,
  295.        0x66,0x66,0x66,0x66,0x3c,0x00,0x00,0x00,
  296.        0x00,0x00,0x00,0x7e,0x66,0x60,0x60,0x30,
  297.        0x30,0x18,0x18,0x0c,0x0c,0x00,0x00,0x00,
  298.        0x00,0x00,0x00,0x3c,0x66,0x66,0x66,0x3c,
  299.        0x66,0x66,0x66,0x66,0x3c,0x00,0x00,0x00,
  300.        0x00,0x00,0x00,0x3c,0x66,0x66,0x66,0x66,
  301.        0x7c,0x60,0x60,0x30,0x1c,0x00,0x00,0x00
  302.        );
  303.  
  304. $notdone = 1;
  305. while ($notdone) {        # Setup loop for daemon
  306.     # Wait for connection...
  307.     if ($daemon) {
  308.     &debug_print(1,"Waiting for connection...\n");
  309.     while (!accept(NS,S)) { # Restart if EINTR
  310.         &give_up("accept: $!")    if ($! != &EINTR);
  311.     }
  312.     open(STDOUT,">&NS");    # Map STDIN and STDOUT to the socket
  313.     open(STDIN,"<&NS");
  314.     }
  315.  
  316.     # Get URL and set counterfile
  317.     $line=<STDIN>;
  318.     ($counterurl) = ($line =~ /GET (.*) HTTP/);
  319.     $counterfile = defined($config{$counterurl}) ?
  320.     $config{$counterurl} : $defcounterfile;
  321.     $leading_zero = defined($options{$counterurl}) ?
  322.     ($options{$counterurl} =~ /zero/) : $defleading_zero;
  323.     $inverse = defined $options{$counterurl} ? 
  324.     ($options{$counterurl} =~ /inverse/) : $definverse;
  325.     &debug_print(1,"url: $counterurl");
  326.     &debug_print(1," w/zero")        if ($leading_zero);
  327.     &debug_print(1,"\n");
  328.  
  329.     # Read and increment the counter file
  330.     while (-f "${counterfile}.lock") { sleep 1 }
  331.     open(LOCK,">${counterfile}.lock");
  332.     close(LOCK);
  333.     # If counter file exists use it, otherwise create a new one
  334.     if (-f "$counterfile" ) {
  335.     open(COUNTERFILE,"<$counterfile") ||
  336.         &give_up("$0: can\'t open $counterfile: $!\n");
  337. #        flock(COUNTERFILE,&LOCK_EX) ||
  338. #        &give_up("$0: can\'t lock $counterfile: $!\n");
  339.     $text = <COUNTERFILE>;
  340.     close(COUNTERFILE);
  341.     } else {
  342.     $text = '0';
  343.     }
  344.  
  345.     $text++;
  346.     $len = length($text) > 7 ? length($text) : 7;
  347.     open(COUNTERFILE,">$counterfile") ||
  348.     &give_up("$0: can\'t open $counterfile: $!\n");
  349.     printf COUNTERFILE "%${len}u\n",$text;
  350.     if ($leading_zero) {
  351.     $text = sprintf("%0${len}u",$text);
  352.     } else {
  353.     $len = length($text);
  354.     $text = sprintf("%${len}u",$text);
  355.     }
  356.     &debug_print(1,"count: $text\n");
  357. #    flock(COUNTERFILE,&LOCK_UN);
  358.     close(COUNTERFILE);
  359.     if ($checkpoint && ($text % $checkpoint == 0)) {
  360.     if ($syslog) {
  361.         &syslog('info',"$counterurl checkpoint: $text");
  362.     } else {
  363.         open(CHECKFILE,">${counterfile}.check") || 
  364.         warn "$0: can\'t open ${counterfile}.check: $!\n";
  365.         print CHECKFILE "%0${len}u\n",$text;
  366.         close(CHECKFILE);
  367.     }
  368.     }
  369.     unlink("${counterfile}.lock");
  370.  
  371.     # Generate an X11 bitmap on STDOUT
  372.     printf STDOUT "#define count_width %d\n#define count_height 16\n", $len*8;
  373.     printf STDOUT "static char count_bits[] = {\n";
  374.     for ($y=0; $y < 16; $y++) {
  375.     for ($x=0; $x < $len; $x++) {
  376.         $d = substr($text,$x,1) - '0';
  377.         print STDOUT '0x';
  378.         if ($inverse) {
  379.         printf STDOUT "%1x",(($digits[($d * 16) + $y] >> 4) ^ 0xf) & 0xf;
  380.         printf STDOUT "%1x",($digits[($d * 16) + $y] ^ 0xf) & 0xf;
  381.         } else {
  382.         printf STDOUT "%1x",($digits[($d * 16) + $y] >> 4) & 0xf;
  383.         printf STDOUT "%1x",$digits[($d * 16) + $y] & 0xf;
  384.         }
  385.         if ($x < $len-1) {
  386.         print STDOUT ',';
  387.         }
  388.     }
  389.     if ($y==15) {
  390.         print STDOUT '};';
  391.     } else {
  392.         print STDOUT ',';
  393.     }
  394.     print STDOUT "\n";
  395.     }
  396.     if ($daemon) {
  397.     close(STDOUT);
  398.     close(STDIN);
  399.     close(NS);
  400.     } else {
  401.     undef($notdone);
  402.     }
  403. }
  404.     
  405. ################### BEGIN PERL/TROFF TRANSITION 
  406. .00 ;    
  407.  
  408. 'di
  409. .nr nl 0-1
  410. .nr % 0
  411. '; __END__ ############## END PERL/TROFF TRANSITION
  412. .TH counter 1 "October 14, 1994"
  413. .SH NAME
  414. counter \- display a user counter for a World Wide Web document
  415. .SH SYNOPSIS
  416. .B counter 
  417. [
  418. .I -dizV
  419. ] [
  420. .I -C interval
  421. ] [
  422. .I -D debuglevel
  423. ] [
  424. .I -f defaultcounterfile
  425. |
  426. .I -c configfile
  427. ] [
  428. .I -i
  429. ] [
  430. .I -p portnum
  431. ]
  432. .SH DESCRIPTION
  433. .B counter
  434. will display a count of users accessing a World Wide Web document.
  435. .LP
  436. The output of 
  437. .B counter
  438. contains an x-bitmap of the current value stored in the counterfile.
  439. This can be used to count the number of accesses to a WWW document, by using
  440. the WWW browser's caching of image files (and therefore they
  441. won't request the image a second time).
  442. .LP
  443. .SH OPTIONS
  444. .TP
  445. .BI \-c file
  446. overrides the default config file \fIcounter.conf\fP.  The config file 
  447. specifies what file should be used to store the count for each URL that is to
  448. be counted.  It contains one line for each counter, and each line is of the
  449. form:
  450. .nf
  451. .in +5
  452. .B URLfile        counterfile    options
  453. .in -5
  454. .fi
  455. \fBURLfile\fP contains just the filename from the counter bitmap URL (with a
  456. leading slash).
  457. The only \fBoptions\fP currently supported are \fIzero\fP and \fIinverse\fP.
  458. Ex.
  459. .nf
  460. .in +5
  461. .B /counter.xbm        /www/counter.txt    zero inverse
  462. .B /counter-home.xbm    /www/counter-home.txt
  463. .in -5
  464. .fi
  465. .TP
  466. .BI \-C checkpoint
  467. causes \fBcounter\fP to checkpoint the count at the interval specified.
  468. This will be done using syslog if available, otherwise, a counterfile is
  469. created with \fI.count\fP appended to the name.
  470. .TP
  471. .B \-d
  472. will cause counter to detach itself from the controlling terminal and
  473. run as a network daemon on the port specified by the \fI-p\fP flag.  This
  474. will also cause any error messages to be output to the console.  If the
  475. \fI-D\fP option is also used, the program will not detach itself from the
  476. terminal, but will instead output the debugging information to stderr.
  477. .TP
  478. .BI \-D level
  479. enables debugging at the level specified.
  480. .TP
  481. .B \-f file
  482. specifies the counter file to use if either an unknown bitmap is specified,
  483. or if the config file cannot be opened.
  484. .TP
  485. .B \-i
  486. causes \fBcounter\fP to output an inverted bitmap (white numbers on a black
  487. background).  This affects only the default counter if a config file is used.
  488. .TP
  489. .BI \-p port
  490. specifies the port number for the daemon to run on.
  491. .TP
  492. .B \-V
  493. will print the version number of the counter script and exit.
  494. .TP
  495. .B \-z
  496. forces \fBcounter\fP to print leading zeros on the counter.  This affects only
  497. the default counter if a config file is used.
  498. .SH INSTALLATION
  499. First you need to decide if you want to run the counter from inetd, or as a
  500. standalone daemon.  You can only run from inetd if you have the ability to
  501. edit system files and restart the inetd daemon.  However, if you are going
  502. to run the counter with a config file, it will run faster if you run it as
  503. a standalone daemon (from inetd, it must reread the config file every
  504. time the counter is accessed).
  505. .LP
  506. If you are going to run it out of inetd, you need to change two of your
  507. network configuration files.  You will need to add the following line to
  508. /etc/services (the 8987 is the port number that will be specified in the 
  509. URL that accesses the counter):
  510. .nf
  511. .in +5
  512. .B counter 8987/tcp
  513. .in -5
  514. .fi
  515. and add the following to /etc/inetd.conf:
  516. .nf
  517. .in +5
  518. .B counter stream tcp nowait www /www/bin/counter counter
  519. .in -5
  520. .fi
  521. \fIWww\fP must be changed to a user who has write access to the counter files.
  522. The \fI/www/bin/counter\fP path needs to be changed to where you 
  523. installed this program, and you can add any of the options above to the 
  524. end of the line as they will be passed to the \fBcounter\fP script
  525. (NOTE: you cannot use \fI-p\fP or \fI-d\fP if running from inetd).
  526. .LP
  527. If you wish to use the counter in more than one document, you either need to 
  528. run multiple copies of this script on different ports, or use a config file
  529. as specified above.  By default, this file is named \fIcounter.conf\fP, and
  530. is located in the same directory as \fBcounter\fP.  This can be overridden
  531. with the \fI-c\fP option.
  532. .LP
  533. At this point, you are ready to test the script by running it from the
  534. command line.  You will need to redirect STDIN to /dev/null, as that is where
  535. \fBcounter\fP expects to see the document URL.  It should return an X11
  536. bitmap of the current value in the default counter file.  If you want to test
  537. \fBcounter\fP with one of the URLs in the config file, you need to pass the
  538. following as input to \fBcounter\fP (it will pause after you start it):
  539. .nf
  540. .in +5
  541. GET /counter.xbm HTTP/1.0
  542. .in -5
  543. .fi
  544. replacing /counter.xbm with the file you want to test from \fIcounter.conf\fP.
  545. .LP
  546. To get this count into your documents, use a URL of the form:
  547. .in +5
  548. .I http://your.server.host:8987/counter.xbm
  549. .in -5
  550. where \fI8987\fP is the port \fBcounter\fP is running on, and counter.xbm is
  551. one of the names in your config file.
  552. .SH FILES
  553. .TP
  554. .B counter.txt
  555. default file which holds the user count
  556. .TP
  557. .B counter.txt.lock
  558. default lock file used to enforce file locking
  559. .TP
  560. .B counter.conf
  561. default counter configuration file
  562. .TP
  563. .B /etc/inted.conf
  564. .TP
  565. .B /etc/services
  566. .SH SEE ALSO
  567. \fBsyslog\fP(3), \fBperl\fP.
  568. .SH BUGS
  569. .LP
  570. The one known problem with \fBcounter\fP is that it will occasionally
  571. zero the count file under heavy loads.  I believe this is caused by a race
  572. condition with the lock files, but have never been able to track it down.
  573. That is the main reason the checkpoint option was added to this version 
  574. of \fBcounter\fP.
  575. .SH CREDITS
  576. Frans van Hoesel (hoesel@chem.rug.nl) originaly wrote a simple 
  577. C counter that I ported to perl.  While his program was a perfectly
  578. good solution to the counting problem, I wanted a version written in
  579. perl that would be easier for me to maintain and modify.
  580. .LP
  581. Since then, it has had a slight case of creeping-featurism, and
  582. now contains several command line flags, a config file, and a man page.
  583. .SH AVAILABILITY
  584. The latest version of 
  585. .B counter
  586. is available through SGI's Silicon Surf WWW site at
  587. .IR http://www.sgi.com/counter.html.  
  588. Just select the counter for a description of the program, and an option
  589. to download the latest version of this script.
  590. .SH AUTHOR
  591. .I Daniel Rich\ \ \ \ <drich@corp.sgi.com>
  592.